/// @tags: NTT DP
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#define rint register int

using std::cin;
using std::cout;

namespace BlueQuantum {

typedef long long LL;

constexpr int maxn = 1 << 19, p = 998244353, g = 3, mod = 998244353;

constexpr inline LL qpow(LL base, int exp = mod - 2) {
  LL res = 1;
  for (; exp; exp >>= 1, base = base * base % mod)
    if (exp & 1) res = res * base % mod;
  return res;
}

constexpr int invg = 332748118;

int n, A[maxn];
LL k;

struct Polynomial {
  static int n;
  static int cvt[maxn << 1];
  int f[maxn << 1];

  inline Polynomial() { memset(f, 0, sizeof(f)); }

  inline int &operator[](int index) { return f[index]; }
  inline const int &operator[](int index) const { return f[index]; }

  inline static void init() {
    int maxl = 1;
    while (maxl < n * 2 + 1) maxl <<= 1;
    for (int i = 1; i < maxl; ++i) cvt[i] = cvt[i >> 1] >> 1 | (i & 1) * (maxl >> 1);
  }

  void ntt(int maxl, int typ);
  Polynomial operator*(const Polynomial &) const;
  Polynomial operator^(LL) const;
} F;

int Polynomial::n, Polynomial::cvt[maxn << 1];

inline void Polynomial::ntt(int maxl, int typ) {
  for (int i = 1; i < maxl; ++i)
    if (i < cvt[i]) std::swap(f[i], f[cvt[i]]);
  for (int i = 2; i <= maxl; i <<= 1) {
    int mid = i >> 1, w = qpow(typ ? g : invg, (p - 1) / i);
    for (int j = 0; j < maxl; j += i) {
      LL wk = 1;
      for (int k = 0; k < mid; ++k, wk = wk * w % p) {
        LL tmp = f[j + k + mid] * wk % mod;
        f[j + k + mid] = (f[j + k] - tmp + p) % p;
        (f[j + k] += tmp) %= p;
      }
    }
  }
  if (typ == 0) {
    LL inv = qpow(maxl);
    for (int i = 0; i < maxl; ++i) {
      f[i] = inv * f[i] % p;
    }
  }
}

inline Polynomial Polynomial::operator*(const Polynomial &rhs) const {
  Polynomial res, a(*this), b(rhs);
  // for (int i = n + 1; i <= n * 2; ++i) a[i] = b[i] = 0;
  int maxl = 1;
  while (maxl < n * 2 + 1) maxl <<= 1;
  a.ntt(maxl, true), b.ntt(maxl, true);
  for (int i = 0; i < maxl; ++i) res[i] = (LL)a[i] * b[i] % p;
  res.ntt(maxl, false);
  for (int i = n + 1; i <= n * 2; ++i) {
    (res[i - n - 1] += res[i]) %= mod;
    res[i] = 0;
  }
  return res;
}

inline Polynomial Polynomial::operator^(LL exp) const {
  Polynomial res, base(*this);
  res[0] = 1;
  for (; exp; exp >>= 1, base = base * base)
    if (exp & 1) res = res * base;
  return res;
}

constexpr int inv2 = 499122177;

inline int main() {
  cin >> n >> k;
  for (int i = 1; i <= n; ++i) {
    cin >> A[i];
    A[0] += A[i];
    A[0] %= mod;
  }
  int n2 = n * 2;
  Polynomial::n = n2 - 1;
  Polynomial::init();
  for (int i = 1, inv = qpow(A[0]); i <= n; ++i) {
    A[i] = (LL)A[i] * inv % mod;
    (F[i] += (LL)inv2 * A[i] % mod) %= mod;
    (F[n2 - i] += (LL)inv2 * A[i] % mod) %= mod;
  }
  F = F ^ k;
  for (int i = n + 1; i < n2; ++i) (F[n2 - i] += F[i]) %= mod;
  for (int i = 0; i <= n; ++i) cout << F[i] << ' ';
  return 0;
}

}  // namespace BlueQuantum

int main() {
#ifndef ONLINE_JUDGE
#ifdef LOCAL
  freopen("/tmp/CodeTmp/testdata.in", "r", stdin);
  freopen("/tmp/CodeTmp/testdata.out", "w", stdout);
#else
  freopen("b.in", "r", stdin);
  freopen("b.out", "w", stdout);
#endif
#endif

  std::ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
  return BlueQuantum::main();
}
